package study.JavaAdvanced;

import java.util.*;

/**
 * date:2025.10.22
 * title:ArrayList
 * author:fzy
 */

//ArrayList是一个可以动态修改数组大小的数组，他跟普通数组的区别就是没有固定大小，可以添加删除元素
    /*
    集合：可调整大小的数组实现
     */
/*
List集合 -- 有序 -- 可重复
List方法特有的方法：
    void add(int index,E param): 在指定位置插入指定元素
    E remove(int index):删除指定所索引处元素，返回删除元素
    E set(int index,E param):修改指定索引出元素，返回修改的元素
    E get(int index):返回指定索引处的元素
    List 集合是有索引的，对索引操作必须要注意越界
 */
public class Java_2 {
    public static void main(String[] arg) {
//        int[] valueArr = {13, 21, 31,2334, 51, 61};
//        ArrayListClass arrayListClass = new ArrayListClass();
//        for (int i : valueArr) {
//            //初始化数组
//            boolean returnValue = arrayListClass.addToList(i);
//            System.out.println(returnValue);
//        }
//        //删除最后一个元素
//        //ArrayList.size()可以获取当前数组的大小
//         int removeValue  =   arrayListClass.deleteToList(arrayListClass.getF_arrayList().size()-1);
//        System.out.println("removeValue:"+removeValue);
//        int returnAddValue = arrayListClass.getToList(0);
//        System.out.println("getReturn:"+returnAddValue);
//        int exchangeValue  = arrayListClass.exChangeToList(1,10);
//        System.out.println("exchangeValue:"+exchangeValue);
//        arrayListClass.printArrayList();
//        arrayListClass.sortToArrayList();
//        arrayListClass.printArrayList();
//        arrayListClass.sortToArrayList(true);
//        arrayListClass.printArrayList();
//        student A = new student("fufuuf",121);
//        student B = new student("ffufufu",123);
//        Scanner scanner = new Scanner(System.in);
//        student[] data = new student[3];
//        for(int i= 0 ;i<3;i++){
//            String name =scanner.next();
//            int age = scanner.nextInt();
//            student Ac = new student(name,age);
//            data[i] = Ac;
//        }
//        StudentManager a = new StudentManager(data);
//        a.printStu();
        ConcurrencyError.ConcurrencyTest();
    }
}

class ConcurrencyError extends Exception{

    static void ConcurrencyTest() {
        List<String> list  = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");
        //并发修改异常
        //实际修改集合的次数和预期修改集合的次数不相等
        //当使用add方法时，实际修改集合次数增加，抛异常
//        Iterator<String> iterator = list.iterator();
//        while (iterator.hasNext()){
//            if(iterator.next().equals("b")){
//                list.add("e");
//            }
//        }
        for(int i=0;i<list.size();i++){
            if(list.get(i).equals("b")){
                list.add("e");
            }
        }
        System.out.println(list);
    }
}

//ArrayList可以用for-each便利，不多说
class ArrayListClass {
    //其中<>中的是泛型，这个知道的，java泛型只能是引用数据类型 --- 基本数据类型||引用数据类型,也就是包装类
    private ArrayList<Integer> f_arrayList = new ArrayList<Integer>();

    public ArrayList<Integer> getF_arrayList() {
        return f_arrayList;
    }

    //数组添加元素,返回是否添加成功
    public boolean addToList(int a) {
        //把数据a添加到这个ArrayList的末尾
        return this.f_arrayList.add(a);
    }

    //获取数组某一个元素，ArrayList的下标|索引从0开始
    public int getToList(int a) {
        return this.f_arrayList.get(a);
    }

    //置换||修改一个元素,index为数组下标，value为替换修改的元素,返回这个值修改之前的大小
    public int exChangeToList(int index, int value) {
        return this.f_arrayList.set(index, value);
    }

    //删除下标a位置的值，返回被删除的这个值
    public int deleteToList(int a) {
        return this.f_arrayList.remove(a);
    }

    public void printArrayList() {
        System.out.println(this.f_arrayList);
    }

    //数组排序,从小到大
    public void sortToArrayList() {
        Collections.sort(this.f_arrayList);
    }

    //大到小
    public void sortToArrayList(Boolean isReverse) {
        if (isReverse) {
            Collections.sort(this.f_arrayList, Collections.reverseOrder());
        } else {
            Collections.sort(this.f_arrayList);
        }

    }
}

/**
 * 知识点
 * 构造方法：ArrayList<T> a = new ArrayList<>()
 * add(value ) 添加一个元素到集合 add(int value),在指定地方添加元素
 * get(int ) 返回一个元素到集合
 * set(int value) 置换一个元素
 * remove(int )删除一个元素
 */
//一些其他的方法，不想多说，用的时候在记住吧铁子
//clone()  复制一份
//contains() 判断是否含有某个值
//indexOf() 返回某个值的下标
//isEmpty() 判空
//toArray||toString ...
//retainAll() 获取两个ArrayList的交集
//ensureCapacity 生成指定大小的动态数组

//案例学生管理系统
class StudentManager {
    private ArrayList<student> dataBase = new ArrayList<>();

    StudentManager(student[] stu) {
        Collections.addAll(this.dataBase, stu);
    }

    void addToDatabase(student stu) {
        this.dataBase.add(stu);
    }

    void printStu() {
        for (student stu : dataBase) {
            System.out.println(stu.name);
        }
    }
}

class student implements Comparable<student>{
    public String name;
    public int age;

    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(student o) {
        if(this.age == o.age&&this.name!= o.name){
            return  1;
        }
        return this.age - o.age;
    }

    @Override
    public boolean equals(Object o) {
        if (o == null || getClass() != o.getClass()) return false;
        student student = (student) o;
        return age == student.age && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}